//package com.example.myproject.sourcecode.ThreadPoolExecutor;
//
//import java.util.HashSet;
//import java.util.concurrent.BlockingQueue;
//import java.util.concurrent.RejectedExecutionHandler;
//import java.util.concurrent.ThreadFactory;
//import java.util.concurrent.ThreadPoolExecutor;
//import java.util.concurrent.atomic.AtomicInteger;
//import java.util.concurrent.locks.Condition;
//import java.util.concurrent.locks.ReentrantLock;
//
///**
// * 该篇来讲解源码
// *
// */
//public class ThreadPoolExecutorSource {
//    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//    private static final int COUNT_BITS = Integer.SIZE - 3;
//    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
//
//    // runState is stored in the high-order bits
////    其中AtomicInteger变量ctl的功能非常强大：利用低29位表示线程池中线程数，通过高3位表示线程池的运行状态：
////    1、RUNNING：-1 << COUNT_BITS，即高3位为111，该状态的线程池会接收新任务，并处理阻塞队列中的任务；
////    2、SHUTDOWN： 0 << COUNT_BITS，即高3位为000，该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；
////    3、STOP ： 1 << COUNT_BITS，即高3位为001，该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；
////    4、TIDYING ： 2 << COUNT_BITS，即高3位为010, 所有的任务都已经终止；
////    5、TERMINATED： 3 << COUNT_BITS，即高3位为011, terminated()方法已经执行完成
//
//    private static final int RUNNING    = -1 << COUNT_BITS;
//    private static final int SHUTDOWN   =  0 << COUNT_BITS;
//    private static final int STOP       =  1 << COUNT_BITS;
//    private static final int TIDYING    =  2 << COUNT_BITS;
//    private static final int TERMINATED =  3 << COUNT_BITS;
//
//    // Packing and unpacking ctl
//    private static int runStateOf(int c)     { return c & ~CAPACITY; }
//    private static int workerCountOf(int c)  { return c & CAPACITY; }
//    private static int ctlOf(int rs, int wc) { return rs | wc; }
//
//    /*
//     * Bit field accessors that don't require unpacking ctl.
//     * These depend on the bit layout and on workerCount being never negative.
//     */
//
//    private static boolean runStateLessThan(int c, int s) {
//        return c < s;
//    }
//
//    private static boolean runStateAtLeast(int c, int s) {
//        return c >= s;
//    }
//
//    private static boolean isRunning(int c) {
//        return c < SHUTDOWN;
//    }
//
//    private boolean compareAndIncrementWorkerCount(int expect) {
//        return ctl.compareAndSet(expect, expect + 1);
//    }
//
//
//    private boolean compareAndDecrementWorkerCount(int expect) {
//        return ctl.compareAndSet(expect, expect - 1);
//    }
//
//    private void decrementWorkerCount() {
//        do {} while (! compareAndDecrementWorkerCount(ctl.get()));
//    }
//
//    private final BlockingQueue<Runnable> workQueue = null;
//
//    private final ReentrantLock mainLock = new ReentrantLock();
//
//    private final HashSet<ThreadPoolExecutor.Worker> workers = new HashSet<ThreadPoolExecutor.Worker>();
//
//    private final Condition termination = mainLock.newCondition();
//
//    private int largestPoolSize;
//
//    private long completedTaskCount;
//
//    private volatile ThreadFactory threadFactory;
//
//    private volatile RejectedExecutionHandler handler;
//
//    private volatile long keepAliveTime;
//
//    private volatile boolean allowCoreThreadTimeOut;
//
//    private volatile int corePoolSize;
//
//    private volatile int maximumPoolSize;
//
//    private static final RejectedExecutionHandler defaultHandler =
//            new ThreadPoolExecutor.AbortPolicy();
//
//    private static final RuntimePermission shutdownPerm =
//            new RuntimePermission("modifyThread");
//
//    public void execute(Runnable command) {
//        //需要执行的任务command为空，抛出空指针异常
//        if (command == null)  // 1
//            throw new NullPointerException();
//
//        /*
//         *执行的流程实际上分为三步
//         *1、如果运行的线程小于corePoolSize，以用户给定的Runable对象新开一个线程去执行
//         *  并且执行addWorker方法会以原子性操作去检查runState和workerCount，以防止当返回false的
//         *  时候添加了不应该添加的线程
//         *2、 如果任务能够成功添加到队列当中，我们仍需要对添加的线程进行双重检查，有可能添加的线程在前
//         *  一次检查时已经死亡，又或者在进入该方法的时候线程池关闭了。所以我们需要复查状态，并有有必
//         *  要的话需要在停止时回滚入列操作，或者在没有线程的时候新开一个线程
//         *3、如果任务无法入列，那我们需要尝试新增一个线程，如果新建线程失败了，我们就知道线程可能关闭了
//         *  或者饱和了，就需要拒绝这个任务
//         *
//         */
//
//        //获取线程池的控制状态
//        int c = ctl.get();  // 2
//
//        //通过workCountOf方法算workerCount值，小于corePoolSize
//        if (workerCountOf(c) < corePoolSize) {
//            //添加任务到worker集合当中
//            if (addWorker(command, true)){
//                return;  //成功返回
//            }
//            //失败的话再次获取线程池的控制状态
//            c = ctl.get();
//        }
//
//        /*
//         *判断线程池是否正处于RUNNING状态
//         *是的话添加Runnable对象到workQueue队列当中
//         */
//        if (isRunning(c) && workQueue.offer(command)) {  // 3
//
//            //再次获取线程池的状态
//            int recheck = ctl.get();
//
//            //再次检查状态
//            //线程池不处于RUNNING状态，将任务从workQueue队列中移除
//            if (! isRunning(recheck) && remove(command))
//                //拒绝任务
//                reject(command);
//                //workerCount等于0
//            else if (workerCountOf(recheck) == 0)  // 4
//                //添加worker
//                addWorker(null, false);
//        }
//        //加入阻塞队列失败，则尝试以线程池最大线程数新开线程去执行该任务
//        else if (!addWorker(command, false))  // 5
//            //执行失败则拒绝任务
//            reject(command);
//    }
//
//    private boolean addWorker(Runnable firstTask, boolean core) {
//        //外部循环标记
//        retry:
//        //外层死循环
//        for (;;) {
//            //获取线程池控制状态
//            int c = ctl.get();
//            //获取runState
//            int rs = runStateOf(c);
//      ​
//            // Check if queue empty only if necessary.
//
//            /**
//             *1.如果线程池runState至少已经是SHUTDOWN
//             *2\. 有一个是false则addWorker失败，看false的情况
//             * - runState==SHUTDOWN，即状态已经大于SHUTDOWN了
//             * - firstTask为null，即传进来的任务为空，结合上面就是runState是SHUTDOWN，但是
//             *  firstTask不为空，代表线程池已经关闭了还在传任务进来
//             * - 队列为空，既然任务已经为空，队列为空，就不需要往线程池添加任务了
//             */
//            if (rs >= SHUTDOWN &&  //runState大于等于SHUTDOWN,初始位RUNNING
//                    ! (rs == SHUTDOWN &&  //runState等于SHUTDOWN
//                            firstTask == null &&  //firstTask为null
//                            ! workQueue.isEmpty()))  //workQueue队列不为空
//                return false;
//      ​
//            //内层死循环
//            for (;;) {
//                //获取线程池的workerCount数量
//                int wc = workerCountOf(c);
//                //如果workerCount超出最大值或者大于corePoolSize/maximumPoolSize
//                //返回false
//                if (wc >= CAPACITY ||
//                        wc >= (core ? corePoolSize : maximumPoolSize))
//                    return false;
//                //通过CAS操作，使workerCount数量+1，成功则跳出循环，回到retry标记
//                if (compareAndIncrementWorkerCount(c))
//                    break retry;
//
//                //CAS操作失败，再次获取线程池的控制状态
//                c = ctl.get();  // Re-read ctl
//                //如果当前runState不等于刚开始获取的runState，则跳出内层循环，继续外层循环
//                if (runStateOf(c) != rs)
//                    continue retry;
//                // else CAS failed due to workerCount change; retry inner loop
//                //CAS由于更改workerCount而失败，继续内层循环
//            }
//        }
//      ​
//        //通过以上循环，能执行到这是workerCount成功+1了
//
//        //worker开始标记
//        boolean workerStarted = false;
//        //worker添加标记
//        boolean workerAdded = false;
//        //初始化worker为null
//        Worker w = null;
//        try {
//            //初始化一个当前Runnable对象的worker对象
//            w = new Worker(firstTask);
//            //获取该worker对应的线程
//            final Thread t = w.thread;
//            //如果线程不为null
//            if (t != null) {
//                //初始线程池的锁
//                final ReentrantLock mainLock = this.mainLock;
//                //获取锁
//                mainLock.lock();
//                try {
//                    // Recheck while holding lock.
//                    // Back out on ThreadFactory failure or if
//                    // shut down before lock acquired.
//                    //获取锁后再次检查，获取线程池runState
//                    int rs = runStateOf(ctl.get());
//      ​
//                    //当runState小于SHUTDOWN或者runState等于SHUTDOWN并且firstTask为null
//                    if (rs < SHUTDOWN ||
//                            (rs == SHUTDOWN && firstTask == null)) {
//
//                        //线程已存活
//                        if (t.isAlive()) // precheck that t is startable
//                            //线程未启动就存活，抛出IllegalThreadStateException异常
//                            throw new IllegalThreadStateException();
//
//                        //将worker对象添加到workers集合当中
//                        workers.add(w);
//                        //获取workers集合的大小
//                        int s = workers.size();
//                        //如果大小超过largestPoolSize
//                        if (s > largestPoolSize)
//                            //重新设置largestPoolSize
//                            largestPoolSize = s;
//                        //标记worker已经被添加
//                        workerAdded = true;
//                    }
//                } finally {
//                    //释放锁
//                    mainLock.unlock();
//                }
//                //如果worker添加成功
//                if (workerAdded) {
//                    //启动线程
//                    t.start();
//                    //标记worker已经启动
//                    workerStarted = true;
//                }
//            }
//        } finally {
//            //如果worker没有启动成功
//            if (! workerStarted)
//                //workerCount-1的操作
//                addWorkerFailed(w);
//        }
//        //返回worker是否启动的标记
//        return workerStarted;
//    }
//
//
//}
